<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/1999/REC-html401-19991224/strict.dtd">
<html><head>
<title>function</title>
</head><body>
<p>[<a href="mxdoc.htm">mainpage</a>]
[<a href="tags.htm">tags</a>]<br>
<h1>tag: function</h1><ul><li>
<a name="unsigned mx_unlock(MX_LOCK* lock)"><code>unsigned mx_unlock(MX_LOCK* lock)</code></a>
<p>
<p><b>Destruct a MX_LOCK</b><p>
This function destroys a MX_LOCK and removes it from it's associated
MX_ATOM object.  If the object has been flagged for deletion (with the
mx_delete() macro) then removal of the last lock caused the MX_ATOM
destructor to be called and (if necessary) memory returned to the operating
system.
<p>
If the release of the lock triggered calling of the object destructor then
the function returns non-zero.  If this occurs then it is not safe to access
the object anymore.  If this function returns false then either:<ol>
<li>Other locks exist for the object.</li>
<li>The object hasn't been deleted yet.</li>
</ol>In either case you can still safely access the object after the unlock.  
(<a href="../include/deds/atom.h">../include/deds/atom.h</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_atom.htm">atom</a>)
<p></li>
<li>
<a name="unsigned mx_lastlock(const MX_LOCK* lock)"><code>unsigned mx_lastlock(const MX_LOCK* lock)</code></a>
<p>
<p><b>Find out if a lock is the last one of an object  </b><p>
(<a href="../include/deds/atom.h">../include/deds/atom.h</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_atom.htm">atom</a>)
<p></li>
<li>
<a name="void* mx__atom(MX_ATOM* atom, MX__ATOM_DESTRUCT destruct, size_t datasize)"><code>void* mx__atom(MX_ATOM* atom, MX__ATOM_DESTRUCT destruct, size_t datasize)</code></a>
<p>
<p><b>Construct an MX_ATOM</b><p>
This internal function constructs an MX_ATOM and registers a
destructor to call when the object gets deleted.  
(<a href="../include/deds/atom.c">../include/deds/atom.c</a>)

<p>If insufficient object size is suggested then the actually allocated
             memory is increased to safely contain an MX_ATOM.  Passing 0 for datasize
             is safe.   
(<a href="../include/deds/atom.c">../include/deds/atom.c</a>)

<p>If no existing MX_ATOM memory is given then memory will be allocated.  
(<a href="../include/deds/atom.c">../include/deds/atom.c</a>)

<p>The address of the newly constructed MX_ATOM is returned.  
(<a href="../include/deds/atom.c">../include/deds/atom.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_atom.htm">atom</a>)
<p></li>
<li>
<a name="void mx_rect_move(MX_RECT* rrect, int x, int y)"><code>void mx_rect_move(MX_RECT* rrect, int x, int y)</code></a>
<p>
<p><b>Move a MX_RECT</b><p>
This function moves a MX_REXT so that the upper left of the rectangle 
is at a given x,y, position.  The size of the rectangle is not changed.  
(<a href="../include/deds/rect.c">../include/deds/rect.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_rect.htm">rect</a>)
<p></li>
<li>
<a name="void mx_rect_resize(MX_RECT* rrect, int w, int h)"><code>void mx_rect_resize(MX_RECT* rrect, int w, int h)</code></a>
<p>
<p><b>Resize a MX_RECT</b><p>
This function resizes a MX_REXT to a given size.  The upper left point 
of the rectangle does not change.   
(<a href="../include/deds/rect.c">../include/deds/rect.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_rect.htm">rect</a>)
<p></li>
<li>
<a name="void* mx__rectatom(MX_RECTATOM_DATA* rectatom, MX__ATOM_DESTRUCT destruct, size_t size)"><code>void* mx__rectatom(MX_RECTATOM_DATA* rectatom, MX__ATOM_DESTRUCT destruct, size_t size)</code></a>
<p>
<p><b>Construct a MX_RECTATOM.  </b><p>
(<a href="../include/deds/rectatom.c">../include/deds/rectatom.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_rectatom.htm">rectatom</a>)
<p></li>
<li>
<a name="void mx__rectatom_place(MX_RECTATOM_DATA* rectatom, const MX_RECT* rrect)"><code>void mx__rectatom_place(MX_RECTATOM_DATA* rectatom, const MX_RECT* rrect)</code></a>
<p>
<p><b>Place a MX_RECTATOM</b><p>
This function places a MX_RECTATOM at a specified area.  
(<a href="../include/deds/rectatom.c">../include/deds/rectatom.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_rectatom.htm">rectatom</a>)
<p></li>
<li>
<a name="void mx_string_realloc(MX_STRING* string, const MX_ALLOC alloc, const MX_FREE dfree)"><code>void mx_string_realloc(MX_STRING* string, const MX_ALLOC alloc, const MX_FREE dfree)</code></a>
<p>
<p><b>Reallocate a MX_STRING</b><p>
This function changes the memory allocation of the text inside a
MX_STRING to the ones in the argumnets.  Memory is allocated using the alloc
function and the current contents of the string is copied to the newly
allocated memory.  The free function will be called when the memory
associated with the text needs to be freed.  
(<a href="../include/deds/string/realloc.c">../include/deds/string/realloc.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_string.htm">string</a>)
<p></li>
<li>
<a name="void mx_string_set(MX_STRING* string, const char* text, int len, const MX_FREE dfree)"><code>void mx_string_set(MX_STRING* string, const char* text, int len, const MX_FREE dfree)</code></a>
<p>
<p><b>Set MX_STRING text and length</b><p>
This function sets the text, length and free function of a MX_STRING
object.  When mx_string_free() is called the free function will be called to
release the memory associated with the text.  The free parameter may be 0 in
which case no function will be called to release the text memory.  
(<a href="../include/deds/string/set.c">../include/deds/string/set.c</a>)

<p>If the len parameter is less than 0 (usually -1) then the string
	is assumed to be zero terminated.  
(<a href="../include/deds/string/set.c">../include/deds/string/set.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_string.htm">string</a>)
<p></li>
<li>
<a name="void mx_string(MX_STRING* string)"><code>void mx_string(MX_STRING* string)</code></a>
<p>
<p><b>Construct a MX_STRING</b><p>
This function initializes a MX_STRING object.  It writes the memory
full with 0 values.  
(<a href="../include/deds/string/string.c">../include/deds/string/string.c</a>)

<p>Since a MX_STRING filled with 0 is correctly constructed then
    static instances dont necessarily have to be constructed before use.  
(<a href="../include/deds/string/string.c">../include/deds/string/string.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_string.htm">string</a>)
<p></li>
<li>
<a name="void mx_string_free(MX_STRING* string)"><code>void mx_string_free(MX_STRING* string)</code></a>
<p>
<p><b>Destruct a MX_STRING</b><p>
This function frees a MX_STRING object.  If the associated free
will be called to release any internal memory.  
(<a href="../include/deds/string/string.c">../include/deds/string/string.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_string.htm">string</a>)
<p></li>
<li>
<a name="const char* mx_string_text(const MX_STRING* string, int* len)"><code>const char* mx_string_text(const MX_STRING* string, int* len)</code></a>
<p>
<p><b>Get MX_STRING text and length</b><p>
This function return the text of the string along with the length
of the text segment.  
(<a href="../include/deds/string/text.c">../include/deds/string/text.c</a>)

<p>The len argument can be 0 in which case the length is not returned.  
(<a href="../include/deds/string/text.c">../include/deds/string/text.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_string.htm">string</a>)
<p></li>
<li>
<a name="int mx_string_len(const MX_STRING* string)"><code>int mx_string_len(const MX_STRING* string)</code></a>
<p>
<p><b>Get MX_STRING length</b><p>
This function return the length of the text segment.  
(<a href="../include/deds/string/text.c">../include/deds/string/text.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_string.htm">string</a>)
<p></li>
<li>
<a name="size_t mx__vector_makeroom(MX__VECTOR_DATA* vect, const size_t num, const size_t place, const size_t sizeofdata)"><code>size_t mx__vector_makeroom(MX__VECTOR_DATA* vect, const size_t num, const size_t place, const size_t sizeofdata)</code></a>
<p>
<p>During appending we expand vectors by doubling thier size with a
        minimum of 16 but a different value might be better in some applications.
        Can a reasonable API be made for this?  
(<a href="../include/deds/vector/makeroom.c">../include/deds/vector/makeroom.c</a>)<br>(library <a href="deds.htm">deds</a> : module <a href="deds_vector.htm">vector</a>)
<p></li>
<li>
<a name="MX_BITMAP* mx_bitmap(int x2, int y2)"><code>MX_BITMAP* mx_bitmap(int x2, int y2)</code></a>
<p>
<p><b>Create a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
Bitmap is derived from MX_ATOM so it must be destroyed with mx_delete().  
(<a href="../include/degfx/bitmap/bitmap.c">../include/degfx/bitmap/bitmap.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_BITMAP* mx_bitmap_tga(const char* filename)"><code>MX_BITMAP* mx_bitmap_tga(const char* filename)</code></a>
<p>
<p><b>Load a bitmap from a TGA file  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
Source taken from the TGA reader from Allegro and extensively modified.  
(<a href="../include/degfx/bitmap/loadtga.c">../include/degfx/bitmap/loadtga.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_BITMAP* mx_bitmap_gif(const char* filename)"><code>MX_BITMAP* mx_bitmap_gif(const char* filename)</code></a>
<p>
<p><b>Load a bitmap from a GIF file  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_BITMAP* mx_bitmap_pcx(const char* filename)"><code>MX_BITMAP* mx_bitmap_pcx(const char* filename)</code></a>
<p>
<p><b>Load a bitmap from a PCX file  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
PCX loading source taken from Allegro source and extensively modified.  
(<a href="../include/degfx/bitmap/loadpcx.c">../include/degfx/bitmap/loadpcx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_BITMAP* mx_bitmap_pcx_greyscale(const char* filename)"><code>MX_BITMAP* mx_bitmap_pcx_greyscale(const char* filename)</code></a>
<p>
<p><b>Load a bitmap from a PCX file and convert it to greyscale  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
This function is primarily intended as a helper by font loading.  
(<a href="../include/degfx/bitmap/loadpcx.c">../include/degfx/bitmap/loadpcx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_BITMAP* mx_bitmap_clone(const MX_BITMAP* other)"><code>MX_BITMAP* mx_bitmap_clone(const MX_BITMAP* other)</code></a>
<p>
<p><b>Make a complete copy of a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="unsigned mx_bitmap_clip(MX_BITMAP* bitmap, const MX_RECT* newclip)"><code>unsigned mx_bitmap_clip(MX_BITMAP* bitmap, const MX_RECT* newclip)</code></a>
<p>
<p><b>Set a bitmaps clipping area   </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="const MX_RECT* mx_bitmap_clip_get(const MX_BITMAP* bitmap)"><code>const MX_RECT* mx_bitmap_clip_get(const MX_BITMAP* bitmap)</code></a>
<p>
<p><b>Return a bitmaps clipping area  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_offset(MX_BITMAP* bitmap, int x1, int y1)"><code>void mx_bitmap_offset(MX_BITMAP* bitmap, int x1, int y1)</code></a>
<p>
<p><b>Offset a bitmap</b><p>
Subsequent drawing on the bitmap will be offset.  
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_BITMAP_ITER mx_bitmap_iter(const MX_BITMAP* bitmap, int x1, int y1)"><code>MX_BITMAP_ITER mx_bitmap_iter(const MX_BITMAP* bitmap, int x1, int y1)</code></a>
<p>
<p><b>Return pixel-level iterator at a given position  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_BITMAP_ITER mx_bitmap_begin(const MX_BITMAP* bitmap)"><code>MX_BITMAP_ITER mx_bitmap_begin(const MX_BITMAP* bitmap)</code></a>
<p>
<p><b>Return pixel-level iterator at the top left position  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_BITMAP_ITER mx_bitmap_end(const MX_BITMAP* bitmap)"><code>MX_BITMAP_ITER mx_bitmap_end(const MX_BITMAP* bitmap)</code></a>
<p>
<p><b>Return pixel-level iterator at the lower right position  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="MX_PIXEL mx_bitmap_getpixel(const MX_BITMAP* bitmap, int x1, int y1)"><code>MX_PIXEL mx_bitmap_getpixel(const MX_BITMAP* bitmap, int x1, int y1)</code></a>
<p>
<p><b>Return pixel a a given position  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
If the coordinates are outside the bitmap area then 0 is returned.  
(<a href="../include/degfx/bitmap/getpixel.c">../include/degfx/bitmap/getpixel.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_pixel(MX_BITMAP* bitmap, int x1, int y1, MX_PIXEL color)"><code>void mx_bitmap_pixel(MX_BITMAP* bitmap, int x1, int y1, MX_PIXEL color)</code></a>
<p>
<p><b>Draw a pixel on a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
If the specified coordinates are outside the area of the bitmap then
    this function does nothing.  
(<a href="../include/degfx/bitmap/pixel.c">../include/degfx/bitmap/pixel.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_vline(MX_BITMAP* bitmap, int x1, int y1, int y2, MX_PIXEL color)"><code>void mx_bitmap_vline(MX_BITMAP* bitmap, int x1, int y1, int y2, MX_PIXEL color)</code></a>
<p>
<p><b>Draw a vertical line on a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_hline(MX_BITMAP* bitmap, int x1, int y1, int x2, MX_PIXEL color)"><code>void mx_bitmap_hline(MX_BITMAP* bitmap, int x1, int y1, int x2, MX_PIXEL color)</code></a>
<p>
<p><b>Draw a horizontal line on a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_line(MX_BITMAP* bitmap, int x1, int y1, int x2, int y2, MX_PIXEL color)"><code>void mx_bitmap_line(MX_BITMAP* bitmap, int x1, int y1, int x2, int y2, MX_PIXEL color)</code></a>
<p>
<p><b>Draw a line on a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_rectfill(MX_BITMAP* bitmap, int x1, int y1, int x2, int y2, MX_PIXEL color)"><code>void mx_bitmap_rectfill(MX_BITMAP* bitmap, int x1, int y1, int x2, int y2, MX_PIXEL color)</code></a>
<p>
<p><b>Draw a filled rectangle on a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
The current implementation uses horizontal lines to fill the rectangle.  
(<a href="../include/degfx/bitmap/rectfill.c">../include/degfx/bitmap/rectfill.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_clear(MX_BITMAP* bitmap, MX_PIXEL color)"><code>void mx_bitmap_clear(MX_BITMAP* bitmap, MX_PIXEL color)</code></a>
<p>
<p><b>Clear a bitmap to a solid color  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_blit(const MX_BITMAP* src, MX_BITMAP* dest, int sx, int sy, int dx, int dy, int w, int h)"><code>void mx_bitmap_blit(const MX_BITMAP* src, MX_BITMAP* dest, int sx, int sy, int dx, int dy, int w, int h)</code></a>
<p>
<p><b>Blit a bitmap onto another bitmap</b><p>
This function uses the pixel transparency of the source bitmap  
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
If the w or h parameter is set to MXDEFAULT the source bitmap width
        (or height) will be used.  
(<a href="../include/degfx/bitmap/blit.c">../include/degfx/bitmap/blit.c</a>)

<p>The curent implementation requires that the source and destination bitmaps be different.  
(<a href="../include/degfx/bitmap/blit.c">../include/degfx/bitmap/blit.c</a>)

<p>If either of the w or h parameters is less than zer this function does nothing.  
(<a href="../include/degfx/bitmap/blit.c">../include/degfx/bitmap/blit.c</a>)

<p>The transparency is handeled per pixel and the source determines
            the transparency.  
(<a href="../include/degfx/bitmap/blit.c">../include/degfx/bitmap/blit.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_blitcopy(const MX_BITMAP* src, MX_BITMAP* dest, int sx, int sy, int dx, int dy, int w, int h)"><code>void mx_bitmap_blitcopy(const MX_BITMAP* src, MX_BITMAP* dest, int sx, int sy, int dx, int dy, int w, int h)</code></a>
<p>
<p><b>Blit a bitmap onto another bitmap</b><p>
This function uses no transparency  
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
The curent implementation requires that the source and destination
        bitmaps be different.  
(<a href="../include/degfx/bitmap/blitcopy.c">../include/degfx/bitmap/blitcopy.c</a>)

<p>If the w or h parameter is set to MXDEFAULT the source bitmap width
        (or height) will be used.  
(<a href="../include/degfx/bitmap/blitcopy.c">../include/degfx/bitmap/blitcopy.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_blittrans(const MX_BITMAP* src, MX_BITMAP* dest, int sx, int sy, int dx, int dy, int w, int h, unsigned long trans)"><code>void mx_bitmap_blittrans(const MX_BITMAP* src, MX_BITMAP* dest, int sx, int sy, int dx, int dy, int w, int h, unsigned long trans)</code></a>
<p>
<p><b>Blit a bitmap onto another bitmap</b><p>
This function uses the a single transparency level  
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
The w and h parameters may be MXDEFAULT and the width of the source
    bitmap will be used.  
(<a href="../include/degfx/bitmap/trans.c">../include/degfx/bitmap/trans.c</a>)

<p>The current implementation requires that the source and destination
        bitmaps not refer to the same bitmap.  
(<a href="../include/degfx/bitmap/trans.c">../include/degfx/bitmap/trans.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_blitstretch(const MX_BITMAP* src, MX_BITMAP* dest, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh)"><code>void mx_bitmap_blitstretch(const MX_BITMAP* src, MX_BITMAP* dest, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh)</code></a>
<p>
<p><b>Stretch-blit a bitmap onto another bitmap</b><p>
This function uses the pixel transparency of the source bitmap  
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>
The default source poisition is 0,0.  
(<a href="../include/degfx/bitmap/stretch.c">../include/degfx/bitmap/stretch.c</a>)

<p>The default source height and width is the height and width of the source bitmap.  
(<a href="../include/degfx/bitmap/stretch.c">../include/degfx/bitmap/stretch.c</a>)

<p>The default destination poisition is 0,0.  
(<a href="../include/degfx/bitmap/stretch.c">../include/degfx/bitmap/stretch.c</a>)

<p>The default destinantion height and width is the height and width of the destination bitmap.  
(<a href="../include/degfx/bitmap/stretch.c">../include/degfx/bitmap/stretch.c</a>)
<p>Bitmap stretch algorithm is very simple and could definetly be improved.  
(<a href="../include/degfx/bitmap/stretch.c">../include/degfx/bitmap/stretch.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_box(MX_BITMAP* bitmap, int x1, int y1, int x2, int y2, int width, MX_PIXEL light, MX_PIXEL dark)"><code>void mx_bitmap_box(MX_BITMAP* bitmap, int x1, int y1, int x2, int y2, int width, MX_PIXEL light, MX_PIXEL dark)</code></a>
<p>
<p><b>Draw a box on a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_frame(MX_BITMAP* bitmap, int x1, int y1, int x2, int y2, int width, MX_PIXEL light, MX_PIXEL dark, MX_PIXEL fill)"><code>void mx_bitmap_frame(MX_BITMAP* bitmap, int x1, int y1, int x2, int y2, int width, MX_PIXEL light, MX_PIXEL dark, MX_PIXEL fill)</code></a>
<p>
<p><b>Draw a frame on a bitmap  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_bitmap_decorate(const MX_BITMAP* src, MX_BITMAP* dest, int x, int y, int x1, int y1, int x2, int y2)"><code>void mx_bitmap_decorate(const MX_BITMAP* src, MX_BITMAP* dest, int x, int y, int x1, int y1, int x2, int y2)</code></a>
<p>
<p><b>Blitting function for drawing gui objects  </b><p>
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="unsigned mx_bitmap_collision(const MX_BITMAP* src, const MX_BITMAP* dest, int sx, int sy, int dx, int dy, unsigned int thresh)"><code>unsigned mx_bitmap_collision(const MX_BITMAP* src, const MX_BITMAP* dest, int sx, int sy, int dx, int dy, unsigned int thresh)</code></a>
<p>
<p><b>Check if two bitmaps overlap on any pixels</b><p>
Pixel level transparency is taken into account  
(<a href="../include/degfx/bitmap.h">../include/degfx/bitmap.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="bitmap.h" unsigned mx_bitmap_collision(const MX_BITMAP* src, const MX_BITMAP* dest, int sx, int sy, int dx, int dy, unsigned int thresh)"><code>bitmap.h" unsigned mx_bitmap_collision(const MX_BITMAP* src, const MX_BITMAP* dest, int sx, int sy, int dx, int dy, unsigned int thresh)</code></a>
<p>
<p>Collision is defined by both bitmaps having a transparency
                less than the threshold on overlapping pixels.  
(<a href="../include/degfx/bitmap/collisio.c">../include/degfx/bitmap/collisio.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="bitmap.h" void mx_bitmap_decorate(const MX_BITMAP* src, MX_BITMAP* dest, int x, int y, int x1, int y1, int x2, int y2)"><code>bitmap.h" void mx_bitmap_decorate(const MX_BITMAP* src, MX_BITMAP* dest, int x, int y, int x1, int y1, int x2, int y2)</code></a>
<p>
<p>The corners of the source bitmap are copied as normal.  
(<a href="../include/degfx/bitmap/decorate.c">../include/degfx/bitmap/decorate.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="bitmap.h" MX_BITMAP_ITER mx_bitmap_iter(const MX_BITMAP* bitmap, int x1, int y1)"><code>bitmap.h" MX_BITMAP_ITER mx_bitmap_iter(const MX_BITMAP* bitmap, int x1, int y1)</code></a>
<p>
<p>If the pixel position is outside the area of the bitmap then 0 is
        returned.  
(<a href="../include/degfx/bitmap/iter.c">../include/degfx/bitmap/iter.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_bitmap.htm">bitmap</a>)
<p></li>
<li>
<a name="void mx_font_default(MX_FONT* font)"><code>void mx_font_default(MX_FONT* font)</code></a>
<p>
<p>The DEGFX system takes over ownership of the specified font.  This is
        done by creating a reference to the specified font marking the font
        for deletion.  So the font is guaranteed to be deleted as necessary
        whevener no objects have references to the font and a new default font
        is set.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="unsigned mx_gfx_start(MX_GFX_ARGS* userargs)"><code>unsigned mx_gfx_start(MX_GFX_ARGS* userargs)</code></a>
<p>
<p><b>Start DEGFX and set the graphics mode  </b><p>
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>If the requested mode has same size, depth, title and driver as
            the previous one then the graphics mode is not changed.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>If the arguments are 0 then default values are used.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>A NULL driver means use the current driver or if there is none, then
        use the default driver.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>Function returns 0 if gfx mode set failed.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>After successful mode set the screen area contains the screen dimensions.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>If a redraw buffer is specified any previous redraw buffer that was
        allocated will be deleted.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>If no redraw buffer specified then one will be allocated and locked.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>The session is incremented after every successfull mode set.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>The MX_GFX_ARGS struct (if present) is modified to the mode information
       actually set by the underlying driver.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="void mx_gfx_stop(void)"><code>void mx_gfx_stop(void)</code></a>
<p>
<p><b>Stop DEGFX</b><p>
This function stops the graphics mode and (depending on the driver)
probably returns to a text mode.  It can be called before the program return
to the operating system however if the user does not do this it will be
done automatically.   
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>The internal graphics redraw buffer is released.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="const MX_GFX_ARGS* mx_gfx_info(void)"><code>const MX_GFX_ARGS* mx_gfx_info(void)</code></a>
<p>
<p>This function returns information about the current graphics mode.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="void mx_gfx_redraw(MX_REDRAW_FUNC redraw)"><code>void mx_gfx_redraw(MX_REDRAW_FUNC redraw)</code></a>
<p>
<p>This function sets the redraw callback.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="void mx_gfx_dirty(const MX_RECT* rect)"><code>void mx_gfx_dirty(const MX_RECT* rect)</code></a>
<p>
<p><b>Mark part of the screen as dirty </b><p>
This function marks a portion of the screen as dirty.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="unsigned mx_gfx_poll(void)"><code>unsigned mx_gfx_poll(void)</code></a>
<p>
<p><b>Poll the DEGFX grpahics/keyboard/mouse system</b><p>
This function causes the conditions of the keyboard and mose to be read
from the system.  This should be done every time you want to read the keyboard
of the mouse.  Most drivers also redraw the screen during the poll.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="unsigned mx_gfx_pointer(int* x, int* y, int* b)"><code>unsigned mx_gfx_pointer(int* x, int* y, int* b)</code></a>
<p>
<p><b>Get the mouse position and state</b><p>
This function reads the mouse pointer position and button state.  The
function return non-zero if a new position has been read.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>If arguments are 0 then they are ignored.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="unsigned mx_gfx_hidepointer(unsigned hide)"><code>unsigned mx_gfx_hidepointer(unsigned hide)</code></a>
<p>
<p><b>Hide the pointer</b><p>
This only works if DEGFX draws the pointer.  This function does nothing on platforms that draw
thier own pointer i.e. Win32GDI.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>Unlike many other graphics libraries you dont have to hide the pointer
      when drawing on the screen.  This is not necessary with DEGFX because drawing
      takes place on an internal redraw buffer and the mouse is only added when
      blitting the innternal redraw buffer to the screen.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="unsigned mx_gfx_key(int* scan, int* ascii)"><code>unsigned mx_gfx_key(int* scan, int* ascii)</code></a>
<p>
<p><b>Return keypress information </b><p>
If new keypress information is available the function return non-zero, otherwise no key has been pressed.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)

<p>If arguments are 0 then they are ignored.  
(<a href="../include/degfx/coregfx.c">../include/degfx/coregfx.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_coregfx.htm">coregfx</a>)
<p></li>
<li>
<a name="void mx_font_default(MX_FONT* font)"><code>void mx_font_default(MX_FONT* font)</code></a>
<p>
<p><b>Set the default font  </b><p>
(<a href="../include/degfx/font.h">../include/degfx/font.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="void mx_font_bitmap_draw(const MX_FONT* font, struct MX_BITMAP* bitmap, const char* text, int len, int x, const int y, const MX_PIXEL fore)"><code>void mx_font_bitmap_draw(const MX_FONT* font, struct MX_BITMAP* bitmap, const char* text, int len, int x, const int y, const MX_PIXEL fore)</code></a>
<p>
<p><b>Draw text onto a bitmap  </b><p>
(<a href="../include/degfx/font.h">../include/degfx/font.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="void mx_font_bitmap_drawblock(const MX_FONT* font, struct MX_BITMAP* bitmap, const char* text, int len, int x, int y, const MX_PIXEL fore)"><code>void mx_font_bitmap_drawblock(const MX_FONT* font, struct MX_BITMAP* bitmap, const char* text, int len, int x, int y, const MX_PIXEL fore)</code></a>
<p>
<p><b>Draw a block of text onto a bitmap  </b><p>
(<a href="../include/degfx/font.h">../include/degfx/font.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="unsigned int mx_font_height(const MX_FONT* font)"><code>unsigned int mx_font_height(const MX_FONT* font)</code></a>
<p>
<p><b>Return the height of a font  </b><p>
(<a href="../include/degfx/font.h">../include/degfx/font.h</a>)<br>
!The height in pixels of a font
This function return the height of a font in pixels.  
(<a href="../include/degfx/font/fontsize.c">../include/degfx/font/fontsize.c</a>)

<p>If the font argument is 0 then the default font be used.  
(<a href="../include/degfx/font/fontsize.c">../include/degfx/font/fontsize.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="unsigned int mx_font_width(const MX_FONT* font, const char* text, int len)"><code>unsigned int mx_font_width(const MX_FONT* font, const char* text, int len)</code></a>
<p>
<p><b>Return the width of a portion of text  </b><p>
(<a href="../include/degfx/font.h">../include/degfx/font.h</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="void mx_font_blocksize(const MX_FONT* font, const char* text, int len, int* tw, int* th, int* last)"><code>void mx_font_blocksize(const MX_FONT* font, const char* text, int len, int* tw, int* th, int* last)</code></a>
<p>
<p><b>Return the size of a block for a portion of text  </b><p>
(<a href="../include/degfx/font.h">../include/degfx/font.h</a>)<br>
The size in pixels of multi-line text
This function determines the area in pixels required to draw text on
a bitamp using mx_font_bitmap_drawblock().  
(<a href="../include/degfx/font/block.c">../include/degfx/font/block.c</a>)

<p>If the font argument is 0 then the default font be used.  
(<a href="../include/degfx/font/block.c">../include/degfx/font/block.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="void mx_font_bitmap_drawblock(const MX_FONT* font, MX_BITMAP* bitmap, const char* text, int len, int x, int y, const MX_PIXEL fore)"><code>void mx_font_bitmap_drawblock(const MX_FONT* font, MX_BITMAP* bitmap, const char* text, int len, int x, int y, const MX_PIXEL fore)</code></a>
<p>
<p><b>Draw multi-line text onto a bitmap</b><p>
This function draws text on a bitamp.  Newline characters (\r or \r\n)
cause the following text to be placed on the following line.  
(<a href="../include/degfx/font/block.c">../include/degfx/font/block.c</a>)

<p>If the font argument is 0 then the default font be used.  
(<a href="../include/degfx/font/block.c">../include/degfx/font/block.c</a>)

<p>The function mx_font_bitmap_draw() function is used internally
                to draw the individual text lines.  
(<a href="../include/degfx/font/block.c">../include/degfx/font/block.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="void mx_font_bitmap_draw(const MX_FONT* font, MX_BITMAP* bitmap, const char* text, int len, int x, const int y, const MX_PIXEL fore)"><code>void mx_font_bitmap_draw(const MX_FONT* font, MX_BITMAP* bitmap, const char* text, int len, int x, const int y, const MX_PIXEL fore)</code></a>
<p>
<p><b>Draw text onto a bitmap</b><p>
This function draws text on a bitmap at a specific position using a specified
font and color.  Only the foreground color is drawn, the pixels 'behind' the 
text are not drawn.  
(<a href="../include/degfx/font/fontdraw.c">../include/degfx/font/fontdraw.c</a>)

<p>If the font argument is 0 then the default font is used.  
(<a href="../include/degfx/font/fontdraw.c">../include/degfx/font/fontdraw.c</a>)

<p>If the length argument is less than zero then the string is assumed to be
	    zero terminated  
(<a href="../include/degfx/font/fontdraw.c">../include/degfx/font/fontdraw.c</a>)

<p>The text drawing is made efficient by skipping text, or portions of
            text that will be clipped.  
(<a href="../include/degfx/font/fontdraw.c">../include/degfx/font/fontdraw.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="unsigned int mx_font_width(const MX_FONT* font, const char* text, int num)"><code>unsigned int mx_font_width(const MX_FONT* font, const char* text, int num)</code></a>
<p>
<p><b>The width in pixels of some text</b><p>
This function return the width of a portion of text in pixels.  
(<a href="../include/degfx/font/fontsize.c">../include/degfx/font/fontsize.c</a>)

<p>If the font argument is 0 then the default font be used.  
(<a href="../include/degfx/font/fontsize.c">../include/degfx/font/fontsize.c</a>)

<p>If the length of characters is less than 0 then the text is assumed
        to be zero terminated.  
(<a href="../include/degfx/font/fontsize.c">../include/degfx/font/fontsize.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="MX_FONT* mx_font_bitmap(const MX_BITMAP* bitmap, int start)"><code>MX_FONT* mx_font_bitmap(const MX_BITMAP* bitmap, int start)</code></a>
<p>
<p><b>Load a font from a bitmap.  </b><p>
(<a href="../include/degfx/font/loadfont.c">../include/degfx/font/loadfont.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="MX_FONT* mx_font_pcx(const char* filename, int start)"><code>MX_FONT* mx_font_pcx(const char* filename, int start)</code></a>
<p>
<p><b>Load a font from a PCX file.  </b><p>
(<a href="../include/degfx/font/loadfont.c">../include/degfx/font/loadfont.c</a>)<br>(library <a href="degfx.htm">degfx</a> : module <a href="degfx_font.htm">font</a>)
<p></li>
<li>
<a name="MX_RECT* mx_defaultrect_data(void)"><code>MX_RECT* mx_defaultrect_data(void)</code></a>
<p>
<p><b>Get default rect informatoin</b><p>
When handling a MX_DEFAULTRECT event, and object can call this function to
get information as to where to put the default rect information.  
(<a href="../include/depui/corepui.h">../include/depui/corepui.h</a>)<br>
During handling the MX_DEFAULTRECT event an object should call this
function to indicate its desired area.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>This function should only be called while handling an MX_DEFAULTRECT event.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_obj_class(void)"><code>void mx_obj_class(void)</code></a>
<p>
<p><b>Class function for MX_OBJECT  </b><p>
(<a href="../include/depui/corepui.h">../include/depui/corepui.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_textual_class(void)"><code>void mx_textual_class(void)</code></a>
<p>
<p><b>Class function for MX_TEXTUAL  </b><p>
(<a href="../include/depui/corepui.h">../include/depui/corepui.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_button_class(void)"><code>void mx_button_class(void)</code></a>
<p>
<p><b>Class function for MX_BUTTON  </b><p>
(<a href="../include/depui/corepui.h">../include/depui/corepui.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_win_class(void)"><code>void mx_win_class(void)</code></a>
<p>
<p><b>Class function for MX_WIN  </b><p>
(<a href="../include/depui/corepui.h">../include/depui/corepui.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_win_handler(MX_WIN* win)"><code>void mx_win_handler(MX_WIN* win)</code></a>
<p>
<p><b>The default window handler function  </b><p>
(<a href="../include/depui/corepui.h">../include/depui/corepui.h</a>)<br>
!The default window handler  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_default_handler(void)"><code>void mx_default_handler(void)</code></a>
<p>
<p><b>The default window handler function  </b><p>
(<a href="../include/depui/corepui.h">../include/depui/corepui.h</a>)<br>
!The default window handler  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If any object of a window is pressed, the window is brought to the top.   
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>This function passes the event to the desination object.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_winborder_class(void)"><code>void mx_winborder_class(void)</code></a>
<p>
<p><b>Class function for MX_WINBORDER  </b><p>
(<a href="../include/depui/corepui.h">../include/depui/corepui.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="unsigned int mx_emit(MX_EVENT event, const void* data, unsigned int datalen)"><code>unsigned int mx_emit(MX_EVENT event, const void* data, unsigned int datalen)</code></a>
<p>
<p><b>Emit an event to parent object</b><p>
This function informs the current objects parent of an event.  This is
indended for very local communication.  This is used between scrollbars (MX_SLIDER) 
and scrollabale areas (MX_SCROLL) to indicate movement of the scrollbar.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="unsigned int mx_inform(MX_EVENT event, const void* data, unsigned int datalen)"><code>unsigned int mx_inform(MX_EVENT event, const void* data, unsigned int datalen)</code></a>
<p>
<p><b>Inform parent window of event</b><p>
This function passes an event to a parent window of the object/window
currently handling an event.  This is intended for child windows to pass
events to thier parents without explicitly knowing who thier parent are.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_answer(unsigned int answer)"><code>void mx_answer(unsigned int answer)</code></a>
<p>
<p><b>Set the answer to an event</b><p>
This function sets the return value of the event.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>This function does not force an end to event handling, you have to do that
        by returning from the event handler.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If this function is called twice during the handling of the event then
        the first return value is forgotten and the last one is used.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_theme_set(const MX_THEME* theme)"><code>void mx_theme_set(const MX_THEME* theme)</code></a>
<p>
<p><b>Set the current theme</b><p>
This function changes the current theme.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>This function does nothing if the requested theme is already being used.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>The current theme is stopped before trying the new one.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If the new theme cannot be started the previous theme is restarted.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If both the new theme and the previous theme can't be started the
    default theme for the platform is found and started.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)
<p>If we get here then NO themes, not even the default, work
        anymore.  Indicate some kind of (platform specific?) fatal error.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>When the new theme is started successfully, all objects in the
        main tree get an MX_THEME_CHANGE event so that they can change their
        sizes or geometry to handle the new theme properly.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="MX_GUIFONT* mx_guifont_load(const char* filename, const char* text)"><code>MX_GUIFONT* mx_guifont_load(const char* filename, const char* text)</code></a>
<p>
<p><b>Load a gui font from a file</b><p>
The request is passed on to the platform code and the DEPUI core code
keeps track of what fonts are in use and what fonts need deleting.   
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="MX_GUIFONT* mx_guifont_index(int i)"><code>MX_GUIFONT* mx_guifont_index(int i)</code></a>
<p>
<p><b>Returns the available gui fonts.  </b><p>
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>Pass a number less than 0 and the default font will be returned.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>Lower indicies return platform builtin fonts.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>Higher indicies return platform loaded fonts.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>Too high indicies returns 0.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="const char* mx_guifont_text(const MX_GUIFONT* guifont)"><code>const char* mx_guifont_text(const MX_GUIFONT* guifont)</code></a>
<p>
<p><b>Get font desriptive text</b><p>
This function return a portion of descriptive text for a font put there
by the platform code.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_guifont_default(MX_GUIFONT* guifont)"><code>void mx_guifont_default(MX_GUIFONT* guifont)</code></a>
<p>
<p><b>Set the default gui font  </b><p>
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="const MX_POINTER_INFO* mx_pointer_info(void)"><code>const MX_POINTER_INFO* mx_pointer_info(void)</code></a>
<p>
<p><b>Returns pointer information  </b><p>
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>It can be called at any time.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="unsigned mx_pointer_hold(void)"><code>unsigned mx_pointer_hold(void)</code></a>
<p>
<p><b>Hold the pointer</b><p>
If the object handling the current event is pointed to by the pointer 
then the object will keep recieving pointer messages even if the pointer 
leaves the object.  This can be 'turned off' by calling <code>mx_pointer_release()
</code>.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If the current object does not have the pointer then this function does nothing.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>This function return non-zero if the pointer has been successfully held.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="unsigned mx_pointer_release(void)"><code>unsigned mx_pointer_release(void)</code></a>
<p>
<p><b>Release the pointer</b><p>
If the object handling the current event has the pointer held using
<code>mx_pointer_hold()</code> then this function 'releases' the pointer.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If the current object is not holding the pointer then this function does nothing.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>This function return non-zero if the pointer has been successfully released.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="const MX_KEY_INFO* mx_key_info(void)"><code>const MX_KEY_INFO* mx_key_info(void)</code></a>
<p>
<p><b>Return keypress information.  </b><p>
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>This function should only be called when handling a MX_KEY or MX_KEY_UNUSED event.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="static void mx__destroy(void* atom)"><code>static void mx__destroy(void* atom)</code></a>
<p>
<p>Should drawing be done in destructor?
        if (mx_tree_parent(obj))
                mx_platform_dirty(MXRECT(obj));  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="const MX_RECT* mx_expose_rect(void)"><code>const MX_RECT* mx_expose_rect(void)</code></a>
<p>
<p>While handling an MX_EXPOSE event we can find out what area of the
screen is being exposed.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="unsigned mx_exposing(void)"><code>unsigned mx_exposing(void)</code></a>
<p>
<p>This function can only be used while handling an MX_EXPOSE event.  It
determines wether we are actually exposing the object or are just pretending
to expose so that we can find out what portions of the screen are used by the
object.  This function should probably not be used by end users, only by
theme designers.   
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="static void mx__expose(MX_OBJ_DATA* obj, const MX_RECT* rect)"><code>static void mx__expose(MX_OBJ_DATA* obj, const MX_RECT* rect)</code></a>
<p>
<p>MX_EXPOSE events dont get passed to
        the window handler.  Instead they go directly to the object class
        function.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx_expose_background(const MX_RECT* rect)"><code>void mx_expose_background(const MX_RECT* rect)</code></a>
<p>
<p>This function can be used while handling an MX_EXPOSE event to tell
the drawing code to make sure that underlying objects are drawn first.  This
is necessary when drawing transparent or non-rectangular objects.  This function
is probably only useful for theme designers. 
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="unsigned mx_start(void)"><code>unsigned mx_start(void)</code></a>
<p>
<p><b>The initialization function for DEPUI.  </b><p>
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If DEPUI has already been started then this function does nothing.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>The default theme is started.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>The default and built-in fonts are loaded.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>The root window is created.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>This function returns non-zero if initialization succeeded.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="int mx_execute(void)"><code>int mx_execute(void)</code></a>
<p>
<p><b>The main gui loop for DEPUI  </b><p>
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If the gui has not yet been initialized with mx_start() this function
    calls mx_start() now.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If this function is being called recursively it returns immediately.
    This possibility makes the source code for a simple main gui function and
    launching a gui window to be exactly the same.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>The first time this function is called it loops until the gui is closed.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If the screen dimensions change between interation of the main gui
        loop then the root object is adjusted to fill the entire screen and
        the entire screen is marked for redrawing.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>The guimain loop will stop if there are no child objects.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If the pointer is moved over an object and that object has
            called mx_obj_wantmove(true) then the object will recieve a
            MX_POINTER_MOVE event whenever the pointer moves over the object.
            See the function mx_obj_wantmove().  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If an object calls mx_pointer_hold() the the object
                will continue recieving pointer messages even after the pointer
                actually leaves the area of the object on screen.  See the function
                mx_pointer_hold().  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If the pointer enters or leaves the area of the object on screen
            then the appropriate object recieve MX_POINTER_LEAVE and MX_POINTER_ENTER
            events.  These event do not occur if an object has called mx_pointer_hold().  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If the pointer is pressed or released then the approriate object
            recieves MX_POINTER_PRESS or MX_POINTER_RELEASE events.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)

<p>If a key is pressed the focus object gets a MX_KEY event.  If the
            focus object uses the key then it should return non-zero from the event
            handler (see function mx_answer()).  If event handler return zero then
            the objects window will recieve a MX_KEY_UNUSED event.  
(<a href="../include/depui/corepui.c">../include/depui/corepui.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_corepui.htm">corepui</a>)
<p></li>
<li>
<a name="void mx__edittext_cursorpos(MX_EDITTEXT_DATA* edit, int newpos)"><code>void mx__edittext_cursorpos(MX_EDITTEXT_DATA* edit, int newpos)</code></a>
<p>
<p>MX_EDITTEXT needs pageup and page down keys  
(<a href="../include/depui/edittext.c">../include/depui/edittext.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_edittext.htm">edittext</a>)
<p></li>
<li>
<a name="void mx_edittext_class(void)"><code>void mx_edittext_class(void)</code></a>
<p>
<p>Add handling of other non-printing ascii keys  
(<a href="../include/depui/edittext.c">../include/depui/edittext.c</a>)
<p>Add handling of pageup/pagedown keys  
(<a href="../include/depui/edittext.c">../include/depui/edittext.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_edittext.htm">edittext</a>)
<p></li>
<li>
<a name="void mx_filesel_refresh(MX_FILESEL* sel)"><code>void mx_filesel_refresh(MX_FILESEL* sel)</code></a>
<p>
<p><b>Refresh file selector contents</b><p>
This function refreshes the directory and file lists of the file selector.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)
<p>Can we add a list of drive letters to the directory list for DOS?  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_filesel.htm">filesel</a>)
<p></li>
<li>
<a name="void mx_filesel_handler(MX_WIN* win)"><code>void mx_filesel_handler(MX_WIN* win)</code></a>
<p>
<p>Pressing enter/return in the filename area causes the directory and
    file lists to be refreshed with the new pattern.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)
<p>Clicking on the directory list causes the directory and file
       lists to be refreshed.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)
<p>Clicking on the file list selects a file.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)
<p>Pressing OK causes a MX_FILESEL_OK event to be sent to the
            parent window.  WHen halding this event the parent window can call
            mx_filesel_info() to get the selected filename.  The file selector
            widnow is destroyed afetr the MX_FILESEL_OK event.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_filesel.htm">filesel</a>)
<p></li>
<li>
<a name="MX_FILESEL* mx_fileselwin(MX_FILESEL* sel, size_t size, MX_HANDLER handler, int theid)"><code>MX_FILESEL* mx_fileselwin(MX_FILESEL* sel, size_t size, MX_HANDLER handler, int theid)</code></a>
<p>
<p><b>Create file selector</b><p>
This function creates a file selector object with a given handler and id number.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)
<p>mx_text_set(&sel->_dirs, "dir", -1, 0);  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)
<p>mx_text_set(&sel->_files, "file", -1, 0);  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)

<p>If the len parameter is less than 0 then the path is assumed to be
        zero terminated.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)

<p>!Allow a file selector to accept an existing (the default) or non-existing file  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)

<p>!File selector information
When a file has been selected with a file selector a MX_FILESEL_OK
event is sent to the parent window.  Then this function can be called to 
determine the filename selected.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)

<p>This function should only be called while handling a MX_FILESEL_OK event.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)

<p>The specified id number must match the one of the file selector.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)

<p>The returned filename is zero terminated.  
(<a href="../include/depui/filesel.c">../include/depui/filesel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_filesel.htm">filesel</a>)
<p></li>
<li>
<a name="void mx_fontsel_refresh(MX_FONTSEL* fsel)"><code>void mx_fontsel_refresh(MX_FONTSEL* fsel)</code></a>
<p>
<p>This function refreshes a font selector dialog with the currently
available fonts.  This function should be called after creating the font
selector and before it gets displayed or gets an MX_GEOMETRY event.  
(<a href="../include/depui/fontsel.c">../include/depui/fontsel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_fontsel.htm">fontsel</a>)
<p></li>
<li>
<a name="MX_FONTSEL* mx_fontselwin(MX_FONTSEL* fsel, size_t size, MX_HANDLER handler, int theid)"><code>MX_FONTSEL* mx_fontselwin(MX_FONTSEL* fsel, size_t size, MX_HANDLER handler, int theid)</code></a>
<p>
<p>mx_text_set(&fsel->_fonts, "fonts", -1, 0);  
(<a href="../include/depui/fontsel.c">../include/depui/fontsel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_fontsel.htm">fontsel</a>)
<p></li>
<li>
<a name="MX_GUIFONT* mx_fontsel_info(const int idnum)"><code>MX_GUIFONT* mx_fontsel_info(const int idnum)</code></a>
<p>
<p><b>Font selection information</b><p>
When a font has been chosen from a font selector dialog the a 
MX_FONTSEL_OK event is sent to the parent window.  This function can be called
when handling that event to determine the font selected.  
(<a href="../include/depui/fontsel.c">../include/depui/fontsel.c</a>)

<p>This function should only be called when handling an MX_FONTSEL_event.  
(<a href="../include/depui/fontsel.c">../include/depui/fontsel.c</a>)

<p>The sepcified id number has to match the one with the selected font.  
(<a href="../include/depui/fontsel.c">../include/depui/fontsel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_fontsel.htm">fontsel</a>)
<p></li>
<li>
<a name="void mx_gfxsel_handler(MX_WIN* win)"><code>void mx_gfxsel_handler(MX_WIN* win)</code></a>
<p>
<p>Pressing the OK button sends a MX_GFXSEL_OK event to the parent
        window and immediatly destroys the graphics mode window.  
(<a href="../include/depui/gfxsel.c">../include/depui/gfxsel.c</a>)
<p>Pressing the APPLY button sends a MX_GFXSEL_OK event to the
        parent window.  
(<a href="../include/depui/gfxsel.c">../include/depui/gfxsel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_gfxsel.htm">gfxsel</a>)
<p></li>
<li>
<a name="MX_GFXSEL* mx_gfxselwin(MX_GFXSEL* sel, size_t size, MX_HANDLER handler, int theid)"><code>MX_GFXSEL* mx_gfxselwin(MX_GFXSEL* sel, size_t size, MX_HANDLER handler, int theid)</code></a>
<p>
<p>mx_text_set(&sel->_res, "Resolution", -1, 0);  
(<a href="../include/depui/gfxsel.c">../include/depui/gfxsel.c</a>)
<p>mx_text_set(&sel->_depth, "Depth", -1, 0);  
(<a href="../include/depui/gfxsel.c">../include/depui/gfxsel.c</a>)
<p>mx_text_set(&sel->_driver, "Driver", -1, 0);  
(<a href="../include/depui/gfxsel.c">../include/depui/gfxsel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_gfxsel.htm">gfxsel</a>)
<p></li>
<li>
<a name="MX_GFXSEL_INFO* mx_gfxsel_info(const int idnum)"><code>MX_GFXSEL_INFO* mx_gfxsel_info(const int idnum)</code></a>
<p>
<p>When handling a MX_GFXSEL_OK event this function can be called to
get information about the graphics mode selected.   
(<a href="../include/depui/gfxsel.c">../include/depui/gfxsel.c</a>)

<p>This function should only be called while handling a MX_GFXSEL_OK event.  
(<a href="../include/depui/gfxsel.c">../include/depui/gfxsel.c</a>)

<p>The specified id number must match the one of the gfxsel selector.  
(<a href="../include/depui/gfxsel.c">../include/depui/gfxsel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_gfxsel.htm">gfxsel</a>)
<p></li>
<li>
<a name="void mx_listelem_class(void)"><code>void mx_listelem_class(void)</code></a>
<p>
<p><b>Class function for MX_LISTELEM  </b><p>
(<a href="../include/depui/list.h">../include/depui/list.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_list.htm">list</a>)
<p></li>
<li>
<a name="void mx_list_class(void)"><code>void mx_list_class(void)</code></a>
<p>
<p><b>Class function for MX_LIST  </b><p>
(<a href="../include/depui/list.h">../include/depui/list.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_list.htm">list</a>)
<p></li>
<li>
<a name="unsigned int mx_platform_font_width(void* pfont, const char* text, int len)"><code>unsigned int mx_platform_font_width(void* pfont, const char* text, int len)</code></a>
<p>
<p>Allegros font witdth should be able to take more than 1024 chars  
(<a href="../include/depui/platform/allegro.c">../include/depui/platform/allegro.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_platform.htm">platform</a>)
<p></li>
<li>
<a name="void mx_scroll_class(void)"><code>void mx_scroll_class(void)</code></a>
<p>
<p><b>Class function for MX_SCROLL  </b><p>
(<a href="../include/depui/scroll.h">../include/depui/scroll.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_scroll.htm">scroll</a>)
<p></li>
<li>
<a name="void mx_vslider_class(void)"><code>void mx_vslider_class(void)</code></a>
<p>
<p><b>Class function for vertical MX_SLIDER  </b><p>
(<a href="../include/depui/slider.h">../include/depui/slider.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_slider.htm">slider</a>)
<p></li>
<li>
<a name="void mx_hslider_class(void)"><code>void mx_hslider_class(void)</code></a>
<p>
<p><b>Class function for horizontal MX_SLIDER  </b><p>
(<a href="../include/depui/slider.h">../include/depui/slider.h</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_slider.htm">slider</a>)
<p></li>
<li>
<a name="void mx__slider_set(MX_SLIDER_DATA* slider, int range, int size, int value)"><code>void mx__slider_set(MX_SLIDER_DATA* slider, int range, int size, int value)</code></a>
<p>
<p>If the range, size or value is MXDEFAULT then the previous value
        is used.  
(<a href="../include/depui/slider.c">../include/depui/slider.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_slider.htm">slider</a>)
<p></li>
<li>
<a name="void mx__slider_to(MX_SLIDER_DATA* slider, int value)"><code>void mx__slider_to(MX_SLIDER_DATA* slider, int value)</code></a>
<p>
<p>If the slider position is changed then a MX_HSCROLL or a MX_VSCROLL
        event is passed to the sliders parent.  
(<a href="../include/depui/slider.c">../include/depui/slider.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_slider.htm">slider</a>)
<p></li>
<li>
<a name="static void mx__sysmenu_popup(void)"><code>static void mx__sysmenu_popup(void)</code></a>
<p>
<p>Kind of dangerous to maintain pointers to the entry text
               of the main menu, maybe make a copy here?  
(<a href="../include/depui/sysmenu.c">../include/depui/sysmenu.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_sysmenu.htm">sysmenu</a>)
<p></li>
<li>
<a name="void mx_sysmenu(void)"><code>void mx_sysmenu(void)</code></a>
<p>
<p><b>Create a system menu  </b><p>
(<a href="../include/depui/sysmenu.c">../include/depui/sysmenu.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_sysmenu.htm">sysmenu</a>)
<p></li>
<li>
<a name="void mx_themesel_refresh(MX_THEMESEL* sel)"><code>void mx_themesel_refresh(MX_THEMESEL* sel)</code></a>
<p>
<p>This function refreshes a theme selector dialog with the currently
available themes.  This function should be called after creating the theme
selector and before it gets displayed or gets an MX_GEOMETRY event.  
(<a href="../include/depui/themesel.c">../include/depui/themesel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_themesel.htm">themesel</a>)
<p></li>
<li>
<a name="void mx_themesel_handler(MX_WIN* win)"><code>void mx_themesel_handler(MX_WIN* win)</code></a>
<p>
<p>Error handling could be better here  
(<a href="../include/depui/themesel.c">../include/depui/themesel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_themesel.htm">themesel</a>)
<p></li>
<li>
<a name="MX_THEMESEL* mx_themeselwin(MX_THEMESEL* sel, size_t size, MX_HANDLER handler, int theid)"><code>MX_THEMESEL* mx_themeselwin(MX_THEMESEL* sel, size_t size, MX_HANDLER handler, int theid)</code></a>
<p>
<p>mx_text_set(&sel->_themes, "themes", -1, 0);  
(<a href="../include/depui/themesel.c">../include/depui/themesel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_themesel.htm">themesel</a>)
<p></li>
<li>
<a name="const MX_THEME* mx_themesel_info(const int idnum)"><code>const MX_THEME* mx_themesel_info(const int idnum)</code></a>
<p>
<p><b>theme selection information</b><p>
When a theme has been chosen from a theme selector dialog the a 
MX_THEMESEL_OK event is sent to the parent window.  This function can be called
when handling that event to determine the theme selected.  
(<a href="../include/depui/themesel.c">../include/depui/themesel.c</a>)

<p>This function should only be called when handling an MX_THEMESEL_event.  
(<a href="../include/depui/themesel.c">../include/depui/themesel.c</a>)

<p>The sepcified id number has to match the one with the selected theme.  
(<a href="../include/depui/themesel.c">../include/depui/themesel.c</a>)<br>(library <a href="depui.htm">depui</a> : module <a href="depui_themesel.htm">themesel</a>)
<p></li>
<li>
<a name="void mx_drs_area(int w, int h)"><code>void mx_drs_area(int w, int h)</code></a>
<p>
<p><b>Initialize dirty-rectangle system</b><p>
This function initializes the dirty-rectangle updating system for a
screen of the given dimensions.  
(<a href="../include/detk/drs.c">../include/detk/drs.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_drs.htm">drs</a>)
<p></li>
<li>
<a name="unsigned mx_drs_dirtychanged(void)"><code>unsigned mx_drs_dirtychanged(void)</code></a>
<p>
<p><b>Return if parts of the screen need updating</b><p>
This function returns zero if there are no dirty areas of the screen.
If the function return false then a following call to mx_drs_update() will
not call the flush callback.  This is useful to determine if a call to
mx_drs_update() could (potentially) update the screen.  It is not guaranteed
that if this function returns true that mx_drs_update() will in fact call
the fluch callback function.  
(<a href="../include/detk/drs.c">../include/detk/drs.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_drs.htm">drs</a>)
<p></li>
<li>
<a name="unsigned mx_drs_update(MX_FLUSH_FUNC dflush)"><code>unsigned mx_drs_update(MX_FLUSH_FUNC dflush)</code></a>
<p>
<p><b>Call the flush function with the parts of the screen needing updating</b><p>
This function calls a user defined callback function with the areas
of the screen marked as dirty by the mx_drs_dirty() function.  
(<a href="../include/detk/drs.c">../include/detk/drs.c</a>)

<p>This functions return zero if no portion of the screen requires
        updating.  
(<a href="../include/detk/drs.c">../include/detk/drs.c</a>)

<p>The updated areas (after possible modification in the callback) are
    guaranteed to bo non-overlapping.  
(<a href="../include/detk/drs.c">../include/detk/drs.c</a>)

<p>The callback function may modify the area to indicate the area
            actually updated.  
(<a href="../include/detk/drs.c">../include/detk/drs.c</a>)

<p>After this function returns the entire dirty area of the screen will have
    been updated though the callback and the entire screen will be marked as
    clean.  
(<a href="../include/detk/drs.c">../include/detk/drs.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_drs.htm">drs</a>)
<p></li>
<li>
<a name="void mx_drs_dirty(const MX_RECT* rrect, unsigned mark)"><code>void mx_drs_dirty(const MX_RECT* rrect, unsigned mark)</code></a>
<p>
<p><b>Mark a portion of the screen as needing updating</b><p>
This function marks a portion of the screen as dirty or clean.  
(<a href="../include/detk/drs.c">../include/detk/drs.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_drs.htm">drs</a>)
<p></li>
<li>
<a name="const char* mx_basename(const char* fname)"><code>const char* mx_basename(const char* fname)</code></a>
<p>
<p>This function returns a pointer to the base name of a file path.  
(<a href="../include/detk/file/basename.c">../include/detk/file/basename.c</a>)
<p>basename taken from the <a href="http://www.delorie.com/djgpp/">DJGPP</a> sources.  
(<a href="../include/detk/file/basename.c">../include/detk/file/basename.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_file.htm">file</a>)
<p></li>
<li>
<a name="int mx_fgetw(FILE* f)"><code>int mx_fgetw(FILE* f)</code></a>
<p>
<p>This function reads a binary word from a FILE using a (Intel? 
Motorola?) byte order.  
(<a href="../include/detk/file/fgetw.c">../include/detk/file/fgetw.c</a>)
<p>fgetw taken from <a href="http://alleg.sourceforge.net/">Allegro</a> sources.  
(<a href="../include/detk/file/fgetw.c">../include/detk/file/fgetw.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_file.htm">file</a>)
<p></li>
<li>
<a name="unsigned mx_filename_match(const char* p, const char* t)"><code>unsigned mx_filename_match(const char* p, const char* t)</code></a>
<p>
<p>This function return non-zero if a filename matches a given pattern.  
Patterns match '*' to one or more characters and '?' to a single character.  
(<a href="../include/detk/file/match.c">../include/detk/file/match.c</a>)

<p>Multiple patterns can be matched by sepaarating them
            with ';' characters.  
(<a href="../include/detk/file/match.c">../include/detk/file/match.c</a>)
<p>Filename matching code taken with permission from the very nice
   webpage of Alessandro Cantaore
   <a href="http://xoomer.virgilio.it/acantato/dev/wildcard/wildmatch.html">
   http://xoomer.virgilio.it/acantato/dev/wildcard/wildmatch.html</a>
 
(<a href="../include/detk/file/match.c">../include/detk/file/match.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_file.htm">file</a>)
<p></li>
<li>
<a name="void mx_path_fix(char* ptr)"><code>void mx_path_fix(char* ptr)</code></a>
<p>
<p>This function corrects a path specifier by removing /./ directories
and moving /../ to the start of the path.  
(<a href="../include/detk/file/pathfix.c">../include/detk/file/pathfix.c</a>)

<p>On MSDOS platforms leading drive specs are ignored.  
(<a href="../include/detk/file/pathfix.c">../include/detk/file/pathfix.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_file.htm">file</a>)
<p></li>
<li>
<a name="void mx_region_clip(MX_REGION* region, const MX_RECT* therect)"><code>void mx_region_clip(MX_REGION* region, const MX_RECT* therect)</code></a>
<p>
<p>This function clips the rectangles in a region by another rectangle.  
After the function returns the none of the rectangles in the region intersect
with the rectangle indicated.  
(<a href="../include/detk/region.c">../include/detk/region.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_region.htm">region</a>)
<p></li>
<li>
<a name="unsigned int mx_utf8_len(const char* s)"><code>unsigned int mx_utf8_len(const char* s)</code></a>
<p>
<p><b>Return number of characters in a UTF-8 encoded character</b><p>
This function return the number of bytes in an encoded UTF-8 character.  
(<a href="../include/detk/utf8.c">../include/detk/utf8.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_utf8.htm">utf8</a>)
<p></li>
<li>
<a name="long mx_utf8_char(const char* s, unsigned int len)"><code>long mx_utf8_char(const char* s, unsigned int len)</code></a>
<p>
<p><b>Read a UTF-8 character</b><p>
This function interprets a number of bytes as a encoded UTF-8 character.  
(<a href="../include/detk/utf8.c">../include/detk/utf8.c</a>)<br>(library <a href="detk.htm">detk</a> : module <a href="detk_utf8.htm">utf8</a>)
<p></li>
</ul><p>Generated by <a href="http://www.deleveld.dds.nl/mxdoc/index.htm">MXDOC</a> 2.2 on Sun Feb  4 15:16:26 2007


</body></html>
